Further macro protection by replacing _[A-Z] with _[A-Z]p git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@145410 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/functional b/include/functional index 59b132c..1ade26f 100644 --- a/include/functional +++ b/include/functional
@@ -198,7 +198,7 @@ . . . - extern unspecified _M; + extern unspecified _Mp; } template <class Operation> @@ -890,44 +890,44 @@ } }; -template<class _R, class _T> +template<class _Rp, class _Tp> inline _LIBCPP_INLINE_VISIBILITY -__mem_fn<_R _T::*> -mem_fn(_R _T::* __pm) +__mem_fn<_Rp _Tp::*> +mem_fn(_Rp _Tp::* __pm) { - return __mem_fn<_R _T::*>(__pm); + return __mem_fn<_Rp _Tp::*>(__pm); } -template<class _R, class _T, class ..._Args> +template<class _Rp, class _Tp, class ..._Args> inline _LIBCPP_INLINE_VISIBILITY -__mem_fn<_R (_T::*)(_Args...)> -mem_fn(_R (_T::* __pm)(_Args...)) +__mem_fn<_Rp (_Tp::*)(_Args...)> +mem_fn(_Rp (_Tp::* __pm)(_Args...)) { - return __mem_fn<_R (_T::*)(_Args...)>(__pm); + return __mem_fn<_Rp (_Tp::*)(_Args...)>(__pm); } -template<class _R, class _T, class ..._Args> +template<class _Rp, class _Tp, class ..._Args> inline _LIBCPP_INLINE_VISIBILITY -__mem_fn<_R (_T::*)(_Args...) const> -mem_fn(_R (_T::* __pm)(_Args...) const) +__mem_fn<_Rp (_Tp::*)(_Args...) const> +mem_fn(_Rp (_Tp::* __pm)(_Args...) const) { - return __mem_fn<_R (_T::*)(_Args...) const>(__pm); + return __mem_fn<_Rp (_Tp::*)(_Args...) const>(__pm); } -template<class _R, class _T, class ..._Args> +template<class _Rp, class _Tp, class ..._Args> inline _LIBCPP_INLINE_VISIBILITY -__mem_fn<_R (_T::*)(_Args...) volatile> -mem_fn(_R (_T::* __pm)(_Args...) volatile) +__mem_fn<_Rp (_Tp::*)(_Args...) volatile> +mem_fn(_Rp (_Tp::* __pm)(_Args...) volatile) { - return __mem_fn<_R (_T::*)(_Args...) volatile>(__pm); + return __mem_fn<_Rp (_Tp::*)(_Args...) volatile>(__pm); } -template<class _R, class _T, class ..._Args> +template<class _Rp, class _Tp, class ..._Args> inline _LIBCPP_INLINE_VISIBILITY -__mem_fn<_R (_T::*)(_Args...) const volatile> -mem_fn(_R (_T::* __pm)(_Args...) const volatile) +__mem_fn<_Rp (_Tp::*)(_Args...) const volatile> +mem_fn(_Rp (_Tp::* __pm)(_Args...) const volatile) { - return __mem_fn<_R (_T::*)(_Args...) const volatile>(__pm); + return __mem_fn<_Rp (_Tp::*)(_Args...) const volatile>(__pm); } // bad_function_call @@ -942,32 +942,32 @@ namespace __function { -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> struct __maybe_derive_from_unary_function { }; -template<class _R, class _A1> -struct __maybe_derive_from_unary_function<_R(_A1)> - : public unary_function<_A1, _R> +template<class _Rp, class _A1> +struct __maybe_derive_from_unary_function<_Rp(_A1)> + : public unary_function<_A1, _Rp> { }; -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> struct __maybe_derive_from_binary_function { }; -template<class _R, class _A1, class _A2> -struct __maybe_derive_from_binary_function<_R(_A1, _A2)> - : public binary_function<_A1, _A2, _R> +template<class _Rp, class _A1, class _A2> +struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> + : public binary_function<_A1, _A2, _Rp> { }; template<class _Fp> class __base; -template<class _R, class ..._ArgTypes> -class __base<_R(_ArgTypes...)> +template<class _Rp, class ..._ArgTypes> +class __base<_Rp(_ArgTypes...)> { __base(const __base&); __base& operator=(const __base&); @@ -978,7 +978,7 @@ virtual void __clone(__base*) const = 0; virtual void destroy() _NOEXCEPT = 0; virtual void destroy_deallocate() _NOEXCEPT = 0; - virtual _R operator()(_ArgTypes&& ...) = 0; + virtual _Rp operator()(_ArgTypes&& ...) = 0; #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const _NOEXCEPT = 0; virtual const std::type_info& target_type() const _NOEXCEPT = 0; @@ -987,139 +987,139 @@ template<class _FD, class _Alloc, class _FB> class __func; -template<class _F, class _Alloc, class _R, class ..._ArgTypes> -class __func<_F, _Alloc, _R(_ArgTypes...)> - : public __base<_R(_ArgTypes...)> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> +class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> + : public __base<_Rp(_ArgTypes...)> { - __compressed_pair<_F, _Alloc> __f_; + __compressed_pair<_Fp, _Alloc> __f_; public: _LIBCPP_INLINE_VISIBILITY - explicit __func(_F __f) : __f_(_VSTD::move(__f)) {} + explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} _LIBCPP_INLINE_VISIBILITY - explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} - virtual __base<_R(_ArgTypes...)>* __clone() const; - virtual void __clone(__base<_R(_ArgTypes...)>*) const; + explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + virtual __base<_Rp(_ArgTypes...)>* __clone() const; + virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; virtual void destroy() _NOEXCEPT; virtual void destroy_deallocate() _NOEXCEPT; - virtual _R operator()(_ArgTypes&& ... __arg); + virtual _Rp operator()(_ArgTypes&& ... __arg); #ifndef _LIBCPP_NO_RTTI virtual const void* target(const type_info&) const _NOEXCEPT; virtual const std::type_info& target_type() const _NOEXCEPT; #endif // _LIBCPP_NO_RTTI }; -template<class _F, class _Alloc, class _R, class ..._ArgTypes> -__base<_R(_ArgTypes...)>* -__func<_F, _Alloc, _R(_ArgTypes...)>::__clone() const +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> +__base<_Rp(_ArgTypes...)>* +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const { - typedef typename _Alloc::template rebind<__func>::other _A; - _A __a(__f_.second()); - typedef __allocator_destructor<_A> _D; - unique_ptr<__func, _D> __hold(__a.allocate(1), _D(__a, 1)); + typedef typename _Alloc::template rebind<__func>::other _Ap; + _Ap __a(__f_.second()); + typedef __allocator_destructor<_Ap> _Dp; + unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); return __hold.release(); } -template<class _F, class _Alloc, class _R, class ..._ArgTypes> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> void -__func<_F, _Alloc, _R(_ArgTypes...)>::__clone(__base<_R(_ArgTypes...)>* __p) const +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const { ::new (__p) __func(__f_.first(), __f_.second()); } -template<class _F, class _Alloc, class _R, class ..._ArgTypes> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> void -__func<_F, _Alloc, _R(_ArgTypes...)>::destroy() _NOEXCEPT +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT { - __f_.~__compressed_pair<_F, _Alloc>(); + __f_.~__compressed_pair<_Fp, _Alloc>(); } -template<class _F, class _Alloc, class _R, class ..._ArgTypes> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> void -__func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT { - typedef typename _Alloc::template rebind<__func>::other _A; - _A __a(__f_.second()); - __f_.~__compressed_pair<_F, _Alloc>(); + typedef typename _Alloc::template rebind<__func>::other _Ap; + _Ap __a(__f_.second()); + __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(this, 1); } -template<class _F, class _Alloc, class _R, class ..._ArgTypes> -_R -__func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> +_Rp +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) { return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI -template<class _F, class _Alloc, class _R, class ..._ArgTypes> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> const void* -__func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT { - if (__ti == typeid(_F)) + if (__ti == typeid(_Fp)) return &__f_.first(); return (const void*)0; } -template<class _F, class _Alloc, class _R, class ..._ArgTypes> +template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> const std::type_info& -__func<_F, _Alloc, _R(_ArgTypes...)>::target_type() const _NOEXCEPT +__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT { - return typeid(_F); + return typeid(_Fp); } #endif // _LIBCPP_NO_RTTI } // __function -template<class _R, class ..._ArgTypes> -class _LIBCPP_VISIBLE function<_R(_ArgTypes...)> - : public __function::__maybe_derive_from_unary_function<_R(_ArgTypes...)>, - public __function::__maybe_derive_from_binary_function<_R(_ArgTypes...)> +template<class _Rp, class ..._ArgTypes> +class _LIBCPP_VISIBLE function<_Rp(_ArgTypes...)> + : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>, + public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> { - typedef __function::__base<_R(_ArgTypes...)> __base; + typedef __function::__base<_Rp(_ArgTypes...)> __base; aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_; - template <class _F> + template <class _Fp> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(const _F&) {return true;} - template <class _R2, class ..._A> + static bool __not_null(const _Fp&) {return true;} + template <class _R2, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(_R2 (*__p)(_A...)) {return __p;} - template <class _R2, class _C, class ..._A> + static bool __not_null(_R2 (*__p)(_Ap...)) {return __p;} + template <class _R2, class _Cp, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(_R2 (_C::*__p)(_A...)) {return __p;} - template <class _R2, class _C, class ..._A> + static bool __not_null(_R2 (_Cp::*__p)(_Ap...)) {return __p;} + template <class _R2, class _Cp, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(_R2 (_C::*__p)(_A...) const) {return __p;} - template <class _R2, class _C, class ..._A> + static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const) {return __p;} + template <class _R2, class _Cp, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(_R2 (_C::*__p)(_A...) volatile) {return __p;} - template <class _R2, class _C, class ..._A> + static bool __not_null(_R2 (_Cp::*__p)(_Ap...) volatile) {return __p;} + template <class _R2, class _Cp, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(_R2 (_C::*__p)(_A...) const volatile) {return __p;} - template <class _R2, class ..._A> + static bool __not_null(_R2 (_Cp::*__p)(_Ap...) const volatile) {return __p;} + template <class _R2, class ..._Ap> _LIBCPP_INLINE_VISIBILITY - static bool __not_null(const function<_R(_A...)>& __p) {return __p;} + static bool __not_null(const function<_Rp(_Ap...)>& __p) {return __p;} - template <class _F, bool = __invokable<_F&, _ArgTypes...>::value> + template <class _Fp, bool = __invokable<_Fp&, _ArgTypes...>::value> struct __callable; - template <class _F> - struct __callable<_F, true> + template <class _Fp> + struct __callable<_Fp, true> { static const bool value = - is_convertible<typename __invoke_of<_F&, _ArgTypes...>::type, - _R>::value; + is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type, + _Rp>::value; }; - template <class _F> - struct __callable<_F, false> + template <class _Fp> + struct __callable<_Fp, false> { static const bool value = false; }; public: - typedef _R result_type; + typedef _Rp result_type; // construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY @@ -1128,9 +1128,9 @@ function(nullptr_t) _NOEXCEPT : __f_(0) {} function(const function&); function(function&&) _NOEXCEPT; - template<class _F> - function(_F, - typename enable_if<__callable<_F>::value>::type* = 0); + template<class _Fp> + function(_Fp, + typename enable_if<__callable<_Fp>::value>::type* = 0); template<class _Alloc> _LIBCPP_INLINE_VISIBILITY @@ -1142,29 +1142,29 @@ function(allocator_arg_t, const _Alloc&, const function&); template<class _Alloc> function(allocator_arg_t, const _Alloc&, function&&); - template<class _F, class _Alloc> - function(allocator_arg_t, const _Alloc& __a, _F __f, - typename enable_if<__callable<_F>::value>::type* = 0); + template<class _Fp, class _Alloc> + function(allocator_arg_t, const _Alloc& __a, _Fp __f, + typename enable_if<__callable<_Fp>::value>::type* = 0); function& operator=(const function&); function& operator=(function&&) _NOEXCEPT; function& operator=(nullptr_t) _NOEXCEPT; - template<class _F> + template<class _Fp> typename enable_if < - __callable<typename decay<_F>::type>::value, + __callable<typename decay<_Fp>::type>::value, function& >::type - operator=(_F&&); + operator=(_Fp&&); ~function(); // function modifiers: void swap(function&) _NOEXCEPT; - template<class _F, class _Alloc> + template<class _Fp, class _Alloc> _LIBCPP_INLINE_VISIBILITY - void assign(_F&& __f, const _Alloc& __a) - {function(allocator_arg, __a, _VSTD::forward<_F>(__f)).swap(*this);} + void assign(_Fp&& __f, const _Alloc& __a) + {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} // function capacity: _LIBCPP_INLINE_VISIBILITY @@ -1177,18 +1177,18 @@ bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete; public: // function invocation: - _R operator()(_ArgTypes...) const; + _Rp operator()(_ArgTypes...) const; #ifndef _LIBCPP_NO_RTTI // function target access: const std::type_info& target_type() const _NOEXCEPT; - template <typename _T> _T* target() _NOEXCEPT; - template <typename _T> const _T* target() const _NOEXCEPT; + template <typename _Tp> _Tp* target() _NOEXCEPT; + template <typename _Tp> const _Tp* target() const _NOEXCEPT; #endif // _LIBCPP_NO_RTTI }; -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>::function(const function& __f) +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>::function(const function& __f) { if (__f.__f_ == 0) __f_ = 0; @@ -1201,9 +1201,9 @@ __f_ = __f.__f_->__clone(); } -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> template <class _Alloc> -function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, const function& __f) { if (__f.__f_ == 0) @@ -1217,8 +1217,8 @@ __f_ = __f.__f_->__clone(); } -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>::function(function&& __f) _NOEXCEPT +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT { if (__f.__f_ == 0) __f_ = 0; @@ -1234,9 +1234,9 @@ } } -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> template <class _Alloc> -function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, function&& __f) { if (__f.__f_ == 0) @@ -1253,43 +1253,43 @@ } } -template<class _R, class ..._ArgTypes> -template <class _F> -function<_R(_ArgTypes...)>::function(_F __f, - typename enable_if<__callable<_F>::value>::type*) +template<class _Rp, class ..._ArgTypes> +template <class _Fp> +function<_Rp(_ArgTypes...)>::function(_Fp __f, + typename enable_if<__callable<_Fp>::value>::type*) : __f_(0) { if (__not_null(__f)) { - typedef __function::__func<_F, allocator<_F>, _R(_ArgTypes...)> _FF; - if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value) + typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF; + if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::move(__f)); } else { - typedef allocator<_FF> _A; - _A __a; - typedef __allocator_destructor<_A> _D; - unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1)); - ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_F>(__a)); + typedef allocator<_FF> _Ap; + _Ap __a; + typedef __allocator_destructor<_Ap> _Dp; + unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); + ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a)); __f_ = __hold.release(); } } } -template<class _R, class ..._ArgTypes> -template <class _F, class _Alloc> -function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f, - typename enable_if<__callable<_F>::value>::type*) +template<class _Rp, class ..._ArgTypes> +template <class _Fp, class _Alloc> +function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, + typename enable_if<__callable<_Fp>::value>::type*) : __f_(0) { typedef allocator_traits<_Alloc> __alloc_traits; if (__not_null(__f)) { - typedef __function::__func<_F, _Alloc, _R(_ArgTypes...)> _FF; - if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value) + typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF; + if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::move(__f)); @@ -1302,27 +1302,27 @@ #else rebind_alloc<_FF>::other #endif - _A; - _A __a(__a0); - typedef __allocator_destructor<_A> _D; - unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1)); + _Ap; + _Ap __a(__a0); + typedef __allocator_destructor<_Ap> _Dp; + unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a)); __f_ = __hold.release(); } } } -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>& -function<_R(_ArgTypes...)>::operator=(const function& __f) +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(const function& __f) { function(__f).swap(*this); return *this; } -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>& -function<_R(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT { if (__f_ == (__base*)&__buf_) __f_->destroy(); @@ -1343,9 +1343,9 @@ } } -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>& -function<_R(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>& +function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT { if (__f_ == (__base*)&__buf_) __f_->destroy(); @@ -1354,21 +1354,21 @@ __f_ = 0; } -template<class _R, class ..._ArgTypes> -template <class _F> +template<class _Rp, class ..._ArgTypes> +template <class _Fp> typename enable_if < - function<_R(_ArgTypes...)>::template __callable<typename decay<_F>::type>::value, - function<_R(_ArgTypes...)>& + function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value, + function<_Rp(_ArgTypes...)>& >::type -function<_R(_ArgTypes...)>::operator=(_F&& __f) +function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) { - function(_VSTD::forward<_F>(__f)).swap(*this); + function(_VSTD::forward<_Fp>(__f)).swap(*this); return *this; } -template<class _R, class ..._ArgTypes> -function<_R(_ArgTypes...)>::~function() +template<class _Rp, class ..._ArgTypes> +function<_Rp(_ArgTypes...)>::~function() { if (__f_ == (__base*)&__buf_) __f_->destroy(); @@ -1376,9 +1376,9 @@ __f_->destroy_deallocate(); } -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> void -function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT +function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT { if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { @@ -1413,9 +1413,9 @@ _VSTD::swap(__f_, __f.__f_); } -template<class _R, class ..._ArgTypes> -_R -function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const +template<class _Rp, class ..._ArgTypes> +_Rp +function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const { #ifndef _LIBCPP_NO_EXCEPTIONS if (__f_ == 0) @@ -1426,61 +1426,61 @@ #ifndef _LIBCPP_NO_RTTI -template<class _R, class ..._ArgTypes> +template<class _Rp, class ..._ArgTypes> const std::type_info& -function<_R(_ArgTypes...)>::target_type() const _NOEXCEPT +function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT { if (__f_ == 0) return typeid(void); return __f_->target_type(); } -template<class _R, class ..._ArgTypes> -template <typename _T> -_T* -function<_R(_ArgTypes...)>::target() _NOEXCEPT +template<class _Rp, class ..._ArgTypes> +template <typename _Tp> +_Tp* +function<_Rp(_ArgTypes...)>::target() _NOEXCEPT { if (__f_ == 0) - return (_T*)0; - return (_T*)__f_->target(typeid(_T)); + return (_Tp*)0; + return (_Tp*)__f_->target(typeid(_Tp)); } -template<class _R, class ..._ArgTypes> -template <typename _T> -const _T* -function<_R(_ArgTypes...)>::target() const _NOEXCEPT +template<class _Rp, class ..._ArgTypes> +template <typename _Tp> +const _Tp* +function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT { if (__f_ == 0) - return (const _T*)0; - return (const _T*)__f_->target(typeid(_T)); + return (const _Tp*)0; + return (const _Tp*)__f_->target(typeid(_Tp)); } #endif // _LIBCPP_NO_RTTI -template <class _R, class... _ArgTypes> +template <class _Rp, class... _ArgTypes> inline _LIBCPP_INLINE_VISIBILITY bool -operator==(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} +operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;} -template <class _R, class... _ArgTypes> +template <class _Rp, class... _ArgTypes> inline _LIBCPP_INLINE_VISIBILITY bool -operator==(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} +operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;} -template <class _R, class... _ArgTypes> +template <class _Rp, class... _ArgTypes> inline _LIBCPP_INLINE_VISIBILITY bool -operator!=(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} +operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;} -template <class _R, class... _ArgTypes> +template <class _Rp, class... _ArgTypes> inline _LIBCPP_INLINE_VISIBILITY bool -operator!=(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} +operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;} -template <class _R, class... _ArgTypes> +template <class _Rp, class... _ArgTypes> inline _LIBCPP_INLINE_VISIBILITY void -swap(function<_R(_ArgTypes...)>& __x, function<_R(_ArgTypes...)>& __y) _NOEXCEPT +swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT {return __x.swap(__y);} template<class _Tp> struct __is_bind_expression : public false_type {}; @@ -1494,7 +1494,7 @@ namespace placeholders { -template <int _N> struct __ph {}; +template <int _Np> struct __ph {}; extern __ph<1> _1; extern __ph<2> _2; @@ -1509,9 +1509,9 @@ } // placeholders -template<int _N> -struct __is_placeholder<placeholders::__ph<_N> > - : public integral_constant<int, _N> {}; +template<int _Np> +struct __is_placeholder<placeholders::__ph<_Np> > + : public integral_constant<int, _Np> {}; template <class _Tp, class _Uj> inline _LIBCPP_INLINE_VISIBILITY @@ -1617,15 +1617,15 @@ { }; -template <class _F, class _BoundArgs, class _TupleUj> +template <class _Fp, class _BoundArgs, class _TupleUj> struct __bind_return; -template <class _F, class ..._BoundArgs, class _TupleUj> -struct __bind_return<_F, tuple<_BoundArgs...>, _TupleUj> +template <class _Fp, class ..._BoundArgs, class _TupleUj> +struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> { typedef typename __invoke_of < - _F&, + _Fp&, typename __mu_return < _BoundArgs, @@ -1634,12 +1634,12 @@ >::type type; }; -template <class _F, class ..._BoundArgs, class _TupleUj> -struct __bind_return<_F, const tuple<_BoundArgs...>, _TupleUj> +template <class _Fp, class ..._BoundArgs, class _TupleUj> +struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> { typedef typename __invoke_of < - _F&, + _Fp&, typename __mu_return < const _BoundArgs, @@ -1648,20 +1648,20 @@ >::type type; }; -template <class _F, class _BoundArgs, size_t ..._Indx, class _Args> +template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> inline _LIBCPP_INLINE_VISIBILITY -typename __bind_return<_F, _BoundArgs, _Args>::type -__apply_functor(_F& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, +typename __bind_return<_Fp, _BoundArgs, _Args>::type +__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) { return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...); } -template<class _F, class ..._BoundArgs> +template<class _Fp, class ..._BoundArgs> class __bind - : public __weak_result_type<typename decay<_F>::type> + : public __weak_result_type<typename decay<_Fp>::type> { - typedef typename decay<_F>::type _Fd; + typedef typename decay<_Fp>::type _Fd; typedef tuple<typename decay<_BoundArgs>::type...> _Td; _Fd __f_; _Td __bound_args_; @@ -1698,10 +1698,10 @@ #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS - template <class _G, class ..._BA> + template <class _Gp, class ..._BA> _LIBCPP_INLINE_VISIBILITY - explicit __bind(_G&& __f, _BA&& ...__bound_args) - : __f_(_VSTD::forward<_G>(__f)), + explicit __bind(_Gp&& __f, _BA&& ...__bound_args) + : __f_(_VSTD::forward<_Gp>(__f)), __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} template <class ..._Args> @@ -1723,16 +1723,16 @@ } }; -template<class _F, class ..._BoundArgs> -struct __is_bind_expression<__bind<_F, _BoundArgs...> > : public true_type {}; +template<class _Fp, class ..._BoundArgs> +struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; -template<class _R, class _F, class ..._BoundArgs> +template<class _Rp, class _Fp, class ..._BoundArgs> class __bind_r - : public __bind<_F, _BoundArgs...> + : public __bind<_Fp, _BoundArgs...> { - typedef __bind<_F, _BoundArgs...> base; + typedef __bind<_Fp, _BoundArgs...> base; public: - typedef _R result_type; + typedef _Rp result_type; #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -1760,10 +1760,10 @@ #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS - template <class _G, class ..._BA> + template <class _Gp, class ..._BA> _LIBCPP_INLINE_VISIBILITY - explicit __bind_r(_G&& __f, _BA&& ...__bound_args) - : base(_VSTD::forward<_G>(__f), + explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) + : base(_VSTD::forward<_Gp>(__f), _VSTD::forward<_BA>(__bound_args)...) {} template <class ..._Args> @@ -1783,25 +1783,25 @@ } }; -template<class _R, class _F, class ..._BoundArgs> -struct __is_bind_expression<__bind_r<_R, _F, _BoundArgs...> > : public true_type {}; +template<class _Rp, class _Fp, class ..._BoundArgs> +struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; -template<class _F, class ..._BoundArgs> +template<class _Fp, class ..._BoundArgs> inline _LIBCPP_INLINE_VISIBILITY -__bind<_F, _BoundArgs...> -bind(_F&& __f, _BoundArgs&&... __bound_args) +__bind<_Fp, _BoundArgs...> +bind(_Fp&& __f, _BoundArgs&&... __bound_args) { - typedef __bind<_F, _BoundArgs...> type; - return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); + typedef __bind<_Fp, _BoundArgs...> type; + return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } -template<class _R, class _F, class ..._BoundArgs> +template<class _Rp, class _Fp, class ..._BoundArgs> inline _LIBCPP_INLINE_VISIBILITY -__bind_r<_R, _F, _BoundArgs...> -bind(_F&& __f, _BoundArgs&&... __bound_args) +__bind_r<_Rp, _Fp, _BoundArgs...> +bind(_Fp&& __f, _BoundArgs&&... __bound_args) { - typedef __bind_r<_R, _F, _BoundArgs...> type; - return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); + typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; + return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } #endif // _LIBCPP_HAS_NO_VARIADICS 